//package com.xuanyue.db.xuan.antlr.impl;
//
//import java.io.BufferedWriter;
//import java.io.File;
//import java.io.FileOutputStream;
//import java.io.OutputStreamWriter;
//import java.text.ParseException;
//import java.text.SimpleDateFormat;
//import java.util.ArrayList;
//import java.util.Collections;
//import java.util.HashMap;
//import java.util.List;
//import java.util.Map;
//import java.util.Map.Entry;
//
//import org.antlr.v4.runtime.tree.TerminalNode;
//
//import com.xuanyue.db.xuan.IResult;
//import com.xuanyue.db.xuan.SeachContext;
//import com.xuanyue.db.xuan.antlr.BitQBaseListener;
//import com.xuanyue.db.xuan.antlr.BitQParser.AddRContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.AndConditionContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.AndNotContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.ConditionElementContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.ConditionExprContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.ExprContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.FieldsContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.FullNameContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.GroupConditionContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.LimitContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.MixContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.OrConditionContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.OrNotContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.Phone_seachContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.RepoContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.ResultContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.SaveAsFileContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.SortByContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.SortEContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.To_dateContext;
//import com.xuanyue.db.xuan.antlr.BitQParser.ValuesContext;
//import com.xuanyue.db.xuan.core.exception.IndexException;
//import com.xuanyue.db.xuan.core.exception.SQLException;
//import com.xuanyue.db.xuan.core.index.BitIndexIterator;
//import com.xuanyue.db.xuan.core.table.IBitIndex;
//import com.xuanyue.db.xuan.core.table.IColumn;
//import com.xuanyue.db.xuan.core.table.ISortElement;
//import com.xuanyue.db.xuan.core.table.IStringEncoding;
//import com.xuanyue.db.xuan.core.table.IXyTable;
//import com.xuanyue.db.xuan.core.table.sort.LimitHandler;
//import com.xuanyue.db.xuan.core.task.Accelerater;
//import com.xuanyue.db.xuan.msg.VLAUETYPE;
//import com.xuanyue.db.xuan.msg.X2YValue;
///**
// * 面向排序和分页的sql解析。
// * 一次查询，返回 记录总数，和结果结果集
// *
// * @author 解观海
// * @email guanhaixie@sina.cn
// * @date 2020年10月16日
// *
// */
//public class BitQListenerImpl extends BitQBaseListener implements IResult{
//	
//	private IXyTable table;//表
//	private int maxSouce;//最大检索资源。
//	private List<String> fl = new ArrayList<>();//列名称
//	private List<Map<String,X2YValue>> r = new ArrayList<>();//结果
//	private int count;//记录数
//	private Map<String,VLAUETYPE> types = new HashMap<>();//列数据类型
//	private Map<String,X2YValue> parameters;//传入参数
//	private List<Map<String, X2YValue>> parametersList;
//	private int parallel;//加速
//	
//	
//	public void setParallel(int parallel) {
//		this.parallel = parallel;
//	}
//	
//	public BitQListenerImpl(int maxSource) {
//		this.maxSouce = maxSource;
//	}
//	public void setParametersList(List<Map<String, X2YValue>> parametersList) {
//		this.parametersList = parametersList;
//	}
//	public void setParameters(Map<String,X2YValue> pV) {
//		this.parameters=pV;
//	}
//	public List<String> getFieldNames(){
//		return fl;
//	}
//	@Override
//	public int count() {
//		return this.count;
//	}
//	@Override
//	public List<Map<String,X2YValue>> getData(){
//		return r;
//	}
//	@Override
//	public Map<String,VLAUETYPE> getTypes(){
//		return this.types;
//	}
//	
//	
//	
//	
//	
//	
//	
//	
//	
//	private String fieldLastName(FullNameContext fnc) {
//		List<TerminalNode> names = fnc.NAME();
//		return names.get( names.size() - 1 ).getText().toLowerCase();
//	}
//	
//	@Override
//	public void exitAddR(AddRContext ctx) {
//		FullNameContext fnl = ctx.fullName();
//		if(fnl==null) {
//			throw new IndexException("table name is null");
//		}
//		List<TerminalNode> names = fnl.NAME();
//		if(names==null||names.size()==0) {
//			throw new IndexException("table name is null");
//		}
//		String tn = names.get(names.size()-1).getText().toLowerCase();
//		table = SeachContext.getTable(tn);
//		if(table==null) {
//			throw new SQLException(String.format("table %s is not exists", tn));
//		}
//		FieldsContext fs = ctx.fields();
//			
//		List<FullNameContext> fieldsList = fs.fullName();//插入的字段
//		List<String> fieldNameList = new ArrayList<>();//插入的字段
//		String cname = null;
//		for(FullNameContext fnc:fieldsList) {
//			cname = fieldLastName(fnc);
//			if(table.getColumn(cname)==null) {
//				throw new SQLException(String.format("Column %s is not exists", cname));
//			}
//			fieldNameList.add(cname);
//		}
//		List<ValuesContext> values = ctx.values();//插入的值
//		if(values==null) {
//			throw new SQLException("values is not exists");
//		}
//		Map<String,Object> n2p = new HashMap<>();//插入记录的列名对应的值
//		Map<String,String> n2k = new HashMap<>();//传参情况下   插入记录的列名对应的参数名称
//		ValuesContext v = null;
//		for(int i=0;i<values.size();i++) {
//			v=values.get(i);
//			TerminalNode transAttr = v.TransArrt();
//			if(transAttr!=null) {
//				String ta = transAttr.getText();
//				String k=ta.substring( 1 , ta.length());
//				n2k.put( fieldNameList.get(i) ,k);//传参时的参数名
//			}else {
//				n2p.put( fieldNameList.get(i) , transeferTo(values.get(i)));
//			}
//		}
//		if(n2k.size()==0) {//没有传递参数，直接插入
//			table.insertInto(n2p);
//			this.count=1;
//		}else {
//			if(parameters!=null) {
//				//插入一条的情况
//				String pname = null;
//				for(Entry<String,String> e:n2k.entrySet()) {
//					pname = e.getValue();
//					if(parameters.containsKey(e.getValue())) {
//						n2p.put(e.getKey(),  parameters.get( pname  )  );
//					}else {
//						throw new SQLException(String.format("parameter %s is not exists", pname ));
//					}
//				}
//				table.insertInto(n2p);
//				this.count=1;
//			}else if(parametersList!=null) {//插入多条的情况
//				//1组装传入的参数为完整的一行
//				List<Map<String, Object>> toAddList = new ArrayList<>();//待插入数据
//				Map<String, Object> n2pTmp = null;//new HashMap<>(n2p);
//				String pname = null;
//				Map<String, X2YValue> params  = null;
//				for(int i=0;i<parametersList.size();i++) {
//					params = parametersList.get(i);
//					n2pTmp = new HashMap<>(n2p);
//					for(Entry<String,String> e:n2k.entrySet()) {//传参方式的值
//						pname = e.getValue();
//						if(params.containsKey(e.getValue())) {
//							n2p.put(e.getKey(),  params.get( pname  )  );
//						}else {
//							throw new SQLException(String.format("at batch index %s ,parameter %s is not exists",i, pname ));
//						}
//					}
//					toAddList.add(n2pTmp);
//				}
//				//2检查数据是否合法
//				String illegalName = null;
//				for(int i=0;i<parametersList.size();i++) {
//					n2pTmp=toAddList.get(i);
//					illegalName=table.insertIntoCheck(n2pTmp);
//					if(illegalName!=null) {
//						throw new SQLException(String.format("at batch index %s ,type ERROR at %s",i ,illegalName));
//					}
//				}
//				this.count=0;
//				//3插入
//				for(Map<String, Object> d:toAddList){
//					table.insertInto(d);
//					this.count++;
//				}
//			}
//		}
//		
//	}
//	private Map<String,Object> disrobe(Map<String, X2YValue> pv){
//		if(pv==null) {
//			return null;
//		}
//		Map<String,Object> r = new HashMap<>();
//		pv.forEach( (k,v)->{
//			r.put(k, v.getValue()  );
//		});
//		return r;
//	}
//
//	@Override
//	public void exitRepo(RepoContext ctx) {
//		List<FullNameContext> fnl = ctx.fullName();
//		if(fnl.size()==0) {
//			throw new IndexException("ERROR at from");
//		}
//		List<TerminalNode> lasts = fnl.get(fnl.size()-1).NAME();
//		String tn = lasts.get(lasts.size()-1).getText().toLowerCase();
//		
//		try {
//			table = SeachContext.getTable(tn);
//			if(table==null) {
//				throw new SQLException(String.format("table %s is not exists", tn));
//			}
//			
//			for(int i=0;i<fl.size();i++) {
//				if("rowid".equals(fl.get(i) )) {
//					types.put( fl.get(i) , VLAUETYPE.INT);
//				}else {
//					IColumn c=table.getColumn(fl.get(i));
//					if(c==null) {
//						throw new SQLException(String.format("column %s is not exists", fl.get(i)));
//					}
//					types.put( fl.get(i) ,table.getType(fl.get(i)));
//				}
//				
//			}
//		} catch (Exception e1) {
//			throw new SQLException("ERROR at table "+tn+" exist?",e1);
//		}
//	}
//	@Override
//	public void exitExpr(ExprContext ctx) {
//		//数据表
//		RepoContext repo = ctx.repo();
//		if(repo==null) {
//			throw new SQLException("ERROR at from");
//		}
//		//where
//		OrConditionContext or= ctx.orCondition();
//		List<IBitIndex> caches = null;// 第0个IBitIndex是 过滤结果后
//		
//		Accelerater accelerater = null;
//		try {
//			caches = table.apply(maxSouce);
//			if(parallel>1) {//多线程加速
//				accelerater = SeachContext.getAccelerate();
//				caches = SeachContext.toAccelerateEncapsulation(caches,accelerater);
//				accelerater.prepare(parallel);//等待加速可用
//			}
//			if(or!=null) {
//				//执行where过滤
//				handleOr(or,caches,0);
//			}else {
//				caches.get(0).copyFrom( table.getMask() );
//			}
//			//统计命中条数
//			this.count = caches.get(0).cardinality();
//			//分页  默认offset=0 然后取出5条记录，语法类似mysql 的limit
//			LimitContext limit = ctx.limit();
//			int offset = 0;
//			int num = 5;
//			if(limit!=null) {
//				List<TerminalNode> on = limit.NUM();
//				if(on.size()==2) {
//					offset = Integer.parseInt(on.get(0).getText().trim());
//					num = Integer.parseInt(on.get(1).getText().trim());
//				}else if(on.size()==1) {
//					num = Integer.parseInt(on.get(1).getText().trim());
//				}else {
//					throw new SQLException("ERROR limit ");
//				}
//			}
//			//排序
//			SortByContext sort = ctx.sortBy();
//			List<ISortElement> sl = new ArrayList<>();
//			if(sort!=null) {
//				List<SortEContext> el = sort.sortE();
//				for(SortEContext e:el) {
//					FullNameContext fnc = e.fullName();
//					List<TerminalNode> ns = fnc.NAME();
//					TerminalNode key = e.STRING();//Map类型的字段时按照摸个key对应的value排序
//					if(key!=null) {
//						sl.addAll( table.getSortE(ns.get(ns.size()-1 ).getText(), e.ASC()==null,valueOfStr( key.getText() )) );
//					}else {
//						sl.addAll( table.getSortE(ns.get(ns.size()-1 ).getText(), e.ASC()==null,null ) );
//					}
//				}
//			}
//			List<Integer> indexs = new ArrayList<>();
//			
//			MixContext mix = ctx.mix();
//			if(mix!=null) {
//				//混合排序 见函数 mixLimit
//				FullNameContext fnc = mix.fullName();
//				List<TerminalNode> ns = fnc.NAME();
//				IBitIndex where_r = caches.get(0);
//				List<TerminalNode> numl = mix.NUM();
//				
//				String fn = ns.get(ns.size()-1 ).getText().toLowerCase();
//				List<IBitIndex> cachesSub = null;//
//				List<Ele> el = new ArrayList<>();
//				IBitIndex out = caches.get(1);//// 第0个IBitIndex是 过滤结果后   第1和存放维度数据的集合。
//				out.setAll(false);
//				for(TerminalNode n:numl) {
//					String key = n.getText();
//					cachesSub = caches.subList(2, caches.size());
//					table.expr(fn, "=", Integer.parseInt(key), cachesSub );
//					cachesSub.get(0).and(where_r);
//					Ele e = new Ele();
//					e.setKey(key);
//					e.setCount(cachesSub.get(0).cardinality());
//					out.or(cachesSub.get(0));
//					el.add(e);
//				}
//				
//				int count = mixLimit(el, offset, num);
//				if(count==0) {
//					//mix的维度数据不足  offset ，则排除维度数据，然后正常排序分页即可
//					where_r.andNot(out);
//					int cx = 0;//各个维度数据的条数加和
//					for(Ele ele:el) {
//						cx+=ele.getCount();
//					}
//					//非维度数据的排序分页
//					LimitHandler handler = new LimitHandler(caches,sort!=null,table.getMask());
//					indexs.addAll(handler.limit(sl, offset-cx, num));
//				}else if(count<num) {
//					//mix的维度数据不足  offset+num个,需要一个补集数据。
//					//1、在补集上取剩余的数据。 num-count条
//					out.not();
//					out.and(where_r);
//					cachesSub = caches.subList(1, caches.size());
//					LimitHandler handler = new LimitHandler(cachesSub,sort!=null,table.getMask());
//					List<Integer> outIndexL = handler.limit(sl, 0, num-count);
//					//2、取得mix的维度数据
//					//cachesSub = caches.subList(1, caches.size());
//					IBitIndex where1 = cachesSub.get(0);
//					for(Ele ele:el) {
//						if(ele.getNum()>0) {//本维度需要取ele.getNum()条数据
//							table.expr(fn, "=", Integer.parseInt(ele.getKey().trim()), cachesSub );
//							where1.and(where_r);
//							indexs.addAll(handler.limit(sl, ele.getStart(), ele.getNum()));
//						}
//					}
//					indexs.addAll(outIndexL);
//				}else if(count==num){
//					//mix的维度数据满足  offset+num个
//					cachesSub = caches.subList(1, caches.size());
//					LimitHandler handler = new LimitHandler(cachesSub,sort!=null,table.getMask());
//					IBitIndex where1 = cachesSub.get(0);
//					for(Ele ele:el) {
//						if(ele.getNum()>0) {
//							table.expr(fn, "=", Integer.parseInt(ele.getKey().trim()), cachesSub );
//							where1.and(where_r);
//							indexs.addAll(handler.limit(sl, ele.getStart(), ele.getNum()));
//						}
//					}
//				}else {
//					throw new SQLException("ERROR mix");
//				}
//			}else {
//				LimitHandler handler = new LimitHandler(caches,sort!=null,table.getMask());
//				indexs.addAll(handler.limit(sl, offset, num));
//			}
//			SaveAsFileContext saveFile = ctx.saveAsFile();
//			if(saveFile!=null) {
//				TerminalNode tarFile = saveFile.STRING();
//				File tf = new File(valueOfStr(tarFile.getText()));
//				BufferedWriter  bw = null;// new BufferedWriter( new OutputStreamWriter( new FileOutputStream(tf), "UTF-8"));
//				
//				try {
//					bw = new BufferedWriter( new OutputStreamWriter( new FileOutputStream(tf), "UTF-8"));
//					IStringEncoding enc = new StringEncoding();
//					
//					int size = fl.size();
//					for(int i=0;i<size;i++) {
//						bw.write(fl.get(i));
//						if(i<size-1) {
//							bw.write("\t");
//						}
//					}
//					
//					if(limit==null) {
//						IBitIndex where = caches.get(0);
//						where.and(table.getMask());
//						BitIndexIterator iter = new BitIndexIterator(where);
//						Map<String,Object> tmp = null;
//						
//						while(iter.hasNext()) {
//							tmp = table.read(iter.next());
//							bw.write("\n");
//							for(int i=0;i<size;i++) {
//								bw.write(enc.encoding(tmp.get(fl.get(i))));
//								if(i<size-1) {
//									bw.write("\t");
//								}
//							}
//						}
//					}else {
//						Map<String,Object> tmp = null;
//						for (int j:indexs) {
//							tmp = table.read(j);
//							bw.write("\n");
//							for(int i=0;i<size;i++) {
//								bw.write(enc.encoding(tmp.get(fl.get(i))));
//								if(i<size-1) {
//									bw.write("\t");
//								}
//							}
//						}
//					}
//					bw.flush();
//				} finally {
//					if(bw!=null)bw.close();
//				}
//			}else {
//				//组织结果
//				Map<String,X2YValue> rx = null;
//				Map<String,Object> tmp = null;
//				for (int j:indexs) {
//					rx = new HashMap<>();
//					tmp = table.read(j);
//					for(String fieldName:fl) {
//						rx.put(fieldName,  new X2YValue( types.get(fieldName), ("rowid".equals(fieldName)? j:tmp.get(fieldName)) ));
//					}
//					r.add(rx);
//				}
//			}
//		} catch (Exception e) {e.printStackTrace();
//			throw new IndexException(e);
//		}finally {
//			if(caches!=null) {
//				if(accelerater!=null) {
//					try {
//						accelerater.free();
//					} catch (InterruptedException e) {
//					}
//					table.returnSource(SeachContext.unpacke(caches));
//				}else {
//					table.returnSource(caches);
//				}
//				
//			}
//		}
//	}
//
//
//	private void handleOr(OrConditionContext or,List<IBitIndex> caches,int from) {
//		List<AndConditionContext> andlist = or.andCondition();
//		List<OrNotContext> ons = or.orNot();
//		
//		List<Boolean> nots = new ArrayList<>();
//		nots.add(or.NOT()!=null);
//		ons.forEach( on->{
//			nots.add( on.NOT()!=null );
//		});
//		
//		IBitIndex r = caches.get(from);
//		r.setAll(false);
//		for(int i=0;i<andlist.size();i++) {
//			handleAnd(andlist.get(i),caches,from+1);
//			if(nots.get(i)) {
//				r.orNot(caches.get(from+1));
//			}else {
//				r.or(caches.get(from+1));
//			}
//			
//		}
//		
//	}
//	private void handleAnd(AndConditionContext and,List<IBitIndex> caches,int from) {
//		List<ConditionElementContext> el = and.conditionElement();
//		List<AndNotContext> ans = and.andNot();
//		
//		List<Boolean> nots = new ArrayList<>();
//		nots.add(false);
//		ans.forEach( an->{
//			nots.add(  an.NOT()!=null );
//		});
//		
//		IBitIndex r = caches.get(from);
//		r.setAll(true);
//		
//		ConditionElementContext e = null;//el.get(0);
//		GroupConditionContext group = null;//e.groupCondition();
//		r.and(caches.get(from +1));
//		for(int i=0;i<el.size();i++) {
//			e = el.get(i);
//			group = e.groupCondition();
//			if(group!=null) {
//				handleGroupCondition(group,caches,from +1);
//			}else {
//				handleConditionExpr(e.conditionExpr(),caches,  from+1);
//			}
//			if( nots.get(i)  ){
//				r.andNot(caches.get(from +1));
//			}else {
//				r.and(caches.get(from +1));
//			}
//		}
//	}
//	private void handleGroupCondition(GroupConditionContext group,List<IBitIndex> caches,int from) {
//		OrConditionContext or = group.orCondition();
//		handleOr(or,caches,from);
//	}
//	private void handleConditionExpr(ConditionExprContext expr,List<IBitIndex> caches,int from) {
//		Phone_seachContext phone = expr.phone_seach();
//		
//		if(phone!=null) {
//			FullNameContext fn = phone.fullName();
//			String method = phone.op.getText().toLowerCase();
//			//PositionMatch|Contains|Has_Every_Char
//			if("positionmatch".equals(method)||"contains".equals(method)||"has_every_char".equals(method)) {
//				;
//			}else {
//				throw new IndexException("method : "+method +" not support");
//			}
//			
//			table.expr(fn.getText(), method, valueOfStr(phone.STRING().getText()), caches.subList(from, caches.size()));
//			return;
//		}
//		
//		
//		FullNameContext fn = expr.fullName();
//		String method = expr.op.getText();
//
//		if("=".equals(method)) {
//			;
//		}else if(">=".equals(method)){
//			;
//		}else if(">".equals(method)){
//			;
//		}else if("<=".equals(method)){
//			;
//		}else if("<".equals(method)){
//			;
//		}else if("contains".equals(method.toLowerCase())){
//			;
//		}else if("positionmatch".equals(method.toLowerCase())){
//			;
//		}else if("phone_seach".equals(method.toLowerCase())){
//			;
//		}else{
//			throw new SQLException("method : "+method +" not support");
//		}
//		
//		Object v = transeferTo(expr.values(),disrobe(parameters));
//		if(!"=".equals(method)&&v==null) {
//			throw new SQLException(String.format("%s is not support", expr.getText()));
//		}
//		
//		//log.debug(String.format("%s %s %s ", fn.getText(),method,v));
//		table.expr(fn.getText(), method, v, caches.subList(from, caches.size()));
//	}
//	private Object transeferTo(ValuesContext value) {
//		return transeferTo(value, null, -1);
//	}
//	private Object transeferTo(ValuesContext value,Map<String, Object> pv) {
//		return transeferTo(value, pv, -1);
//	}
////	private Object transeferTo(ValuesContext value,Map<String, X2YValue> pv) {
////		return transeferTo(value, disrobe(pv), -1);
////	}
//	private Object transeferTo(ValuesContext value,Map<String, Object> pv,int index) {
//		
//		Object v = null;
//		TerminalNode sv = value.STRING();
//		if(sv!=null) {
//			v = valueOfStr(sv.getText());
//		}
//		
//		TerminalNode iv = value.NUM();
//		if(iv!=null) {
//			String ivs = iv.getText();
//			if(ivs.contains(".")  ||ivs.contains("f")) {
//				v = Float.parseFloat(ivs);
//			}else if(ivs.contains("l")){
//				v = Long.parseLong( ivs.substring(0, ivs.length()-1));
//			}else {
//				v = Integer.parseInt(ivs);
//			}
//		}
//		
//		To_dateContext to_data = value.to_date();
//		
//		if(to_data!=null) {
//			List<TerminalNode> ss =to_data.STRING();
//			SimpleDateFormat formatter = new SimpleDateFormat(valueOfStr(ss.get(0).getText()));
//			try {
//				v = formatter.parse(valueOfStr(ss.get(1).getText()));
//			} catch (ParseException e) {
//				e.printStackTrace();
//			}
//		}
//		
//		if("true".equals( value.getText().toLowerCase() )) {
//			v = true;
//		}else if("false".equals( value.getText().toLowerCase() )) {
//			v = false;
//		}
//		
//		TerminalNode transAttr = value.TransArrt();
//		if(transAttr!=null) {
//			String ta = transAttr.getText();
//			String k=ta.substring( 1 , ta.length());
//			if(!pv.containsKey( k )) {
//				if(index==-1) {
//					throw new SQLException(String.format("the parameter %s not exists", k));
//				}else {
//					throw new SQLException(String.format("the parameter %s not exists , at batch index %s", k,index));
//				}
//			}
//			v =pv.get(k);
//		}
//		
//		return v;
//	}
//	private String valueOfStr(String text) {
//		return (text==null?null:text.substring(1, text.length()-1));
//	}
//	
//	/**
//	 * 阶梯函数
//	 * 计算多维度混合排序。
//	 * 例如：
//	 *   数据是分成三类：
//	 *   男装：8件   
//	 *   女装    10件
//	 *   童装    11件。
//	 *  
//	 *  现在需要先按照价格排序，分页查询，页面大小为8，并且要求按类别纵向编号
//	 *   男装：   M1  M2  M3  M4  M5  M6  M7  M8
//	 *   女装：   N1  N2  N3  N4  N5  N6  N7  N8   N9  N10
//	 *   童装：   T1  T2  T3  T4  T5  T6  T7  T8   T9   T10   T11
//	 *   
//	 *   上面的得到顺序为：
//	 *   M1,N1,T1 ,M2,N2,T2 ,M3,N3,T3 ,M4,N4,T4, M5,N5,T5, M6,N6,T6, M7,N7,T7, M8,N8,T8, N9,T9, N10,T10, T11
//	 *   
//	 *   则第一页为如下方括号包含的商品。
//	 *   男装： [M1  M2  M3]  M4  M5  M6  M7  M8
//	 *   女装： [N1  N2  N3]  N4  N5  N6  N7  N8   N9  N10
//	 *   童装： [T1  T2]  T3  T4  T5  T6  T7  T8   T9   T10   T11
//	 *   
//	 *   则第二页为如下方括号包含的商品。
//	 *   男装： M1  M2  M3  [M4  M5  M6]  M7  M8
//	 *   女装： N1  N2  N3  [N4  N5] N6   N7  N8   N9  N10
//	 *   童装： T1  T2 [T3  T4  T5]  T6   T7  T8   T9   T10   T11
//	 *   
//	 * @param el
//	 * @param offset
//	 * @param num
//	 */
//	private static int mixLimit(List<Ele> el,int offset,int num) {
//		Collections.sort(el);
//		Ele e = null;
//		int start = 0;
//		out:for(int i=0;i<el.size();i++) {
//			e = el.get(i);
//			if(offset<=(e.getCount()-start)*(el.size()-i)) {
//				//记录起始位置。
//				int x = offset%(el.size()-i);
//				for(int j=i;j<el.size();j++) {
//					if(x>0) {
//						el.get( j ).setStart(offset/(el.size()-i) + start+1);
//						x--;
//					}else {
//						el.get( j ).setStart(offset/(el.size()-i) + start);
//					}
//				}
//				//计算结束位置
//				offset+=num;
//				for(int j=i;j<el.size();j++) {
//					e= el.get(j);
//					if(offset<=(e.getCount()-start)*(el.size()-j)) {
//						x = offset%(el.size()-j);
//						for(int k=j;k<el.size();k++) {
//							if(x>0) {
//								el.get( k ).setNum(offset/(el.size()-j) + start+1);
//								x--;
//							}else {
//								el.get( k ).setNum(offset/(el.size()-j) + start);
//							}
//						}
//						break out;//
//					}else {
//						e.setNumSurplus();
//						offset-=(e.getCount()-start)*(el.size()-j);
//						start=e.getCount();
//						
//					}
//				}
//				break out;//
//			}else {
//				offset-=(e.getCount()-start)*(el.size()-i);
//				start=e.getCount();
//				
//			}
//		}
//		
//		int c = 0;
//		for(Ele ele:el) {
//			c+=ele.getNum();
//		}
//		return c;
//	}
//	
//	
//	
//	
//}
